Course: Python Training
Topic: Introduction to Functional Programming in Python
Course URL: https://www.justacademy.co/course-detail/python-training
Demo Registration: https://www.justacademy.co/register-for-course-demo
JustAcademy Homepage: https://www.justacademy.co/
Functional programming is a programming paradigm that emphasizes the use of functions to perform computations and transform data. Instead of relying heavily on changing variables and modifying shared state, functional programming encourages developers to create small, reusable functions that accept inputs and return outputs.
Python is a multi-paradigm programming language. It supports procedural programming, object-oriented programming, and functional programming. Developers can combine these approaches within the same application depending on the requirements.
Functional programming is particularly useful for data processing, mathematical calculations, data analysis, filtering records, transforming collections, and building reusable business logic.
def calculate_square(number):
return number * number
result = calculate_square(5)
print(result)Output:
25The function accepts a number, calculates its square, and returns the result. It does not need to modify any external variable.
After studying this topic, learners should be able to:
map() and filter() functions.functools.reduce() for suitable accumulation tasks.In Python, functions are first-class objects. This means functions can be assigned to variables, passed as arguments to other functions, returned from functions, and stored in collections.
def greet(name):
return f"Hello, {name}!"
greeting_function = greet
print(greeting_function("Aarav"))Output:
Hello, Aarav!The variable greeting_function refers to the same function as greet. Assigning greet without parentheses stores the function reference instead of executing the function immediately.
A pure function produces the same result for the same inputs and does not cause observable side effects. Its output depends only on its arguments, not on external mutable state.
def add_numbers(a, b):
return a + b
print(add_numbers(10, 20))
print(add_numbers(10, 20))Output:
30
30This function is predictable because it always adds the two supplied numbers and does not change anything outside the function.
Immutability means that an existing value or object cannot be changed after creation. Functional-style programming often avoids modifying existing collections and instead creates new collections containing the required values.
numbers = [1, 2, 3, 4]
doubled_numbers = [number * 2 for number in numbers]
print("Original:", numbers)
print("Transformed:", doubled_numbers)Output:
Original: [1, 2, 3, 4]
Transformed: [2, 4, 6, 8]The original list remains unchanged. Python lists are mutable, so immutability here is a coding practice rather than a property enforced by the language.
Function composition combines smaller functions so that the result of one function becomes the input of another. This approach helps build complex operations from simpler, reusable parts.
def double(number):
return number * 2
def add_five(number):
return number + 5
def process_number(number):
return add_five(double(number))
print(process_number(10))Output:
25The number 10 is doubled to 20, and then 5 is added to produce 25.
| Paradigm | Main Focus | Common Techniques | Typical Use |
|---|---|---|---|
| Procedural programming | Sequence of instructions | Variables, loops, procedures | Scripts and step-by-step tasks |
| Object-oriented programming | Objects and their behavior | Classes, methods, attributes | Large applications and domain models |
| Functional programming | Functions and data transformations | Pure functions, mapping, filtering | Data pipelines and reusable calculations |
These paradigms are not mutually exclusive. A Python application can use classes to represent business entities and functional techniques to process the data associated with those entities.
A higher-order function is a function that accepts another function as an argument, returns a function, or does both. This allows the same function to perform different operations depending on the function supplied to it.
def apply_operation(number, operation):
return operation(number)
def square(number):
return number ** 2
def cube(number):
return number ** 3
print(apply_operation(4, square))
print(apply_operation(4, cube))Output:
16
64The function apply_operation() delegates the calculation to the supplied function. This makes it reusable for different operations without changing its implementation.
A lambda function is a small anonymous function created using the lambda keyword. A lambda expression contains a single expression, and the value of that expression is returned automatically.
lambda arguments: expressionadd = lambda a, b: a + b
print(add(8, 4))Output:
12students = [
("Asha", 85),
("Rohan", 72),
("Meera", 93)
]
students_sorted = sorted(students, key=lambda student: student[1])
print(students_sorted)Output:
[('Rohan', 72), ('Asha', 85), ('Meera', 93)]The key argument specifies that the records should be sorted by their second item, which represents the score.
Use a named function with def when the logic is complex or needs a descriptive name. Avoid deeply nested lambda expressions because they can make code difficult to maintain.
The built-in map() function applies a function to each item in an iterable and produces an iterator containing the results.
map(function, iterable)numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda number: number ** 2, numbers))
print(squares)Output:
[1, 4, 9, 16, 25]def convert_to_uppercase(word):
return word.upper()
words = ["python", "functional", "programming"]
uppercase_words = list(map(convert_to_uppercase, words))
print(uppercase_words)Output:
['PYTHON', 'FUNCTIONAL', 'PROGRAMMING']In Python 3, map() returns an iterator rather than a list. The list() constructor consumes that iterator and stores its results in a list.
The built-in filter() function selects items from an iterable when a supplied function returns a truthy value. It is useful when only certain elements satisfy a condition.
filter(function, iterable)numbers = [1, 2, 3, 4, 5, 6, 7, 8]
even_numbers = list(
filter(lambda number: number % 2 == 0, numbers)
)
print(even_numbers)Output:
[2, 4, 6, 8]users = [
{"name": "Asha", "active": True},
{"name": "Rohan", "active": False},
{"name": "Meera", "active": True}
]
active_users = list(
filter(lambda user: user["active"], users)
)
print(active_users)Output:
[
{'name': 'Asha', 'active': True},
{'name': 'Meera', 'active': True}
]The filtering function checks each dictionary's active field and retains records whose value is truthy.
The reduce() function combines iterable items into a single accumulated result by repeatedly applying a function. It is available from the functools module.
from functools import reduce
reduce(function, iterable, initializer)from functools import reduce
numbers = [10, 20, 30, 40]
total = reduce(
lambda accumulated, number: accumulated + number,
numbers,
0
)
print(total)Output:
100The accumulator starts at 0. Each item is added to the accumulated result until all numbers have been processed.
from functools import reduce
numbers = [2, 3, 4]
product = reduce(
lambda accumulated, number: accumulated * number,
numbers,
1
)
print(product)Output:
24For ordinary sums and products, Python's sum() and math.prod() are often clearer. Use reduce() when the accumulation operation is more specialized.
| Function | Purpose | Result | Example |
|---|---|---|---|
map() |
Transform every item | Iterator of transformed values | Convert prices after a discount |
filter() |
Select matching items | Iterator of selected values | Find products in stock |
reduce() |
Accumulate items into one result | Single result | Calculate a combined total |
These operations can be combined into a data-processing pipeline. However, a pipeline should remain understandable and should not be made unnecessarily complicated.
List comprehensions provide a concise way to build lists by transforming or filtering elements from an iterable. Although they are not exclusive to functional programming, they are commonly used in functional-style Python code.
numbers = [1, 2, 3, 4, 5]
squares = [number ** 2 for number in numbers]
print(squares)Output:
[1, 4, 9, 16, 25]numbers = [1, 2, 3, 4, 5, 6]
even_numbers = [number for number in numbers if number % 2 == 0]
print(even_numbers)Output:
[2, 4, 6]# Using map()
squares_map = list(map(lambda number: number ** 2, numbers))
# Using a list comprehension
squares_comprehension = [number ** 2 for number in numbers]For straightforward transformations, list comprehensions are often easier to read. Using map() with an existing named function can also be clear and expressive.
Lazy evaluation delays producing values until they are requested. Python generators and iterators such as those returned by map() and filter() support this approach.
numbers = range(1, 6)
squares = (number ** 2 for number in numbers)
for square in squares:
print(square)Output:
1
4
9
16
25The generator calculates values as the loop requests them. It does not create a complete list of all squares in advance.
Generators are generally consumed as they are iterated. If a generator has been exhausted, create a new generator to process the sequence again.
A side effect occurs when a function changes external state or interacts with the outside environment. Examples include modifying global variables, changing shared lists, writing to files, sending network requests, and printing messages.
def add_item(items, item):
items.append(item)
return items
products = ["Laptop"]
add_item(products, "Mouse")
print(products)Output:
['Laptop', 'Mouse']The original list changes because lists are mutable and the function modifies the list passed to it.
def with_item(items, item):
return items + [item]
products = ["Laptop"]
updated_products = with_item(products, "Mouse")
print(products)
print(updated_products)Output:
['Laptop']
['Laptop', 'Mouse']This alternative leaves the original list unchanged. Creating copies can have a performance cost for large collections, so choose the approach that best balances clarity and efficiency.
A closure is a function that retains access to variables from its enclosing scope even after the outer function has returned. Closures can be used to create configurable functions.
def make_multiplier(factor):
def multiply(number):
return number * factor
return multiply
double = make_multiplier(2)
triple = make_multiplier(3)
print(double(10))
print(triple(10))Output:
20
30The inner function remembers the value of factor associated with its closure. This technique is useful for configurable transformations, callbacks, and function factories.
Recursion occurs when a function calls itself to solve a smaller version of the same problem. It is used in functional programming and other programming paradigms.
def factorial(number):
if number < 0:
raise ValueError("Number must be non-negative")
if number in (0, 1):
return 1
return number * factorial(number - 1)
print(factorial(5))Output:
120The base case stops recursion when the number is 0 or 1. Each recursive call reduces the problem size. Python has a recursion depth limit, so iteration may be more suitable for calculations requiring very deep recursion.
Partial function application creates a new callable by fixing some arguments of an existing function. Python provides functools.partial() for this purpose.
from functools import partial
def calculate_price(price, tax_rate):
return price + (price * tax_rate)
calculate_with_tax = partial(
calculate_price,
tax_rate=0.18
)
print(calculate_with_tax(1000))
print(calculate_with_tax(2000))Output:
1180.0
2360.0The tax rate is fixed at 18%, so the new callable requires only the price argument. This is useful when the same configuration is applied repeatedly.
The operator module provides functions corresponding to common Python operators. These functions can be passed to higher-order functions as alternatives to simple lambda expressions.
from operator import add, mul
numbers = [1, 2, 3, 4]
total = sum(numbers)
products = list(map(mul, [2, 3, 4], [10, 10, 10]))
print(total)
print(products)Output:
10
[20, 30, 40]Other useful functions include operator.itemgetter() for selecting items by index or key and operator.attrgetter() for retrieving object attributes. These can make sorting and transformation operations more concise.
A data pipeline applies a sequence of transformations to raw data. Functional techniques help keep each stage small and reusable.
products = [
{"name": "Laptop", "price": 50000, "available": True},
{"name": "Mouse", "price": 800, "available": True},
{"name": "Keyboard", "price": 1500, "available": False},
{"name": "Monitor", "price": 12000, "available": True}
]
available_products = filter(
lambda product: product["available"],
products
)
discounted_prices = map(
lambda product: {
"name": product["name"],
"discounted_price": round(product["price"] * 0.90, 2)
},
available_products
)
result = list(discounted_prices)
print(result)Output:
[
{'name': 'Laptop', 'discounted_price': 45000.0},
{'name': 'Mouse', 'discounted_price': 720.0},
{'name': 'Monitor', 'discounted_price': 10800.0}
]The first stage removes unavailable products. The second stage creates new records containing the discounted prices. The original product dictionaries are not modified.
| Area | Functional Technique | Example |
|---|---|---|
| Data analysis | Mapping and filtering | Clean and transform records |
| E-commerce | Pure calculation functions | Calculate discounts and taxes |
| Reporting | Aggregation and comprehensions | Generate totals and summaries |
| Text processing | String transformations | Normalize and filter text |
| Web applications | Reusable functions | Validate and transform request data |
| Automation | Function composition | Process files through multiple stages |
| Financial calculations | Pure functions | Calculate fees, percentages, and totals |
| Mistake | Problem | Recommended Practice |
|---|---|---|
| Using lambda for complex logic | Reduces readability | Use a named function |
| Using reduce() for every calculation | Makes simple operations harder to understand | Prefer appropriate built-ins |
| Forgetting that map() returns an iterator | Results may not display as expected | Iterate over it or convert it to a list |
| Reusing an exhausted iterator | Previously consumed values are not produced again | Create a fresh iterator when needed |
| Assuming lists are immutable | Other code can modify their contents | Avoid mutation when practical |
| Ignoring side effects | Results may depend on hidden state changes | Separate transformations from external operations |
| Overusing functional constructs | Code can become unnecessarily abstract | Choose the clearest implementation |
map() and filter() when they make the intention clearer.reduce() when a custom accumulation is genuinely needed.Objective: Filter passing students, apply bonus points, and calculate the average adjusted score using functional-style transformations.
students = [
{"name": "Asha", "score": 82},
{"name": "Rohan", "score": 35},
{"name": "Meera", "score": 91},
{"name": "Kabir", "score": 48},
{"name": "Tara", "score": 27}
]
passing_students = filter(
lambda student: student["score"] >= 40,
students
)
adjusted_students = list(
map(
lambda student: {
"name": student["name"],
"score": min(student["score"] + 5, 100)
},
passing_students
)
)
if adjusted_students:
total_score = sum(
student["score"] for student in adjusted_students
)
average_score = total_score / len(adjusted_students)
else:
average_score = 0
print("Adjusted student scores:")
for student in adjusted_students:
print(student)
print("Average adjusted score:", average_score)Output:
Adjusted student scores:
{'name': 'Asha', 'score': 87}
{'name': 'Meera', 'score': 96}
{'name': 'Kabir', 'score': 53}
Average adjusted score: 78.66666666666667This project demonstrates filtering, mapping, aggregation, and avoiding changes to the original student records. The sum() function is used because it expresses the total calculation more clearly than a custom reduction.
map() to convert a list of names to uppercase.filter() to select numbers divisible by both 3 and 5.functools.reduce() to find the maximum value in a non-empty list.Functional programming is a programming style that emphasizes functions, predictable computations, and data transformations while minimizing unnecessary state changes and side effects.
Yes. Python supports functional programming alongside procedural and object-oriented programming.
A pure function returns the same result for the same inputs and does not cause observable side effects.
A higher-order function accepts another function as an argument, returns a function, or does both.
A lambda function is an anonymous function expression that contains a single expression and returns its value.
map() transforms each item in an iterable, whereas filter() selects items that satisfy a condition.
reduce() is defined in the functools module and accumulates iterable items into a single result.
Immutability means that a value or object cannot be changed after creation. Functional-style code often avoids modifying existing collections and returns new results instead.
Lazy evaluation delays producing values until they are requested. Python iterators and generators commonly support this technique.
Their outputs depend on their inputs, making them easier to test without setting up or cleaning up external state.
No. A loop may be more readable for some tasks. Developers should select the approach that makes the code easiest to understand and maintain.
Yes. Classes can represent application entities while pure functions handle calculations, validation, and data transformation.
map() transforms items, while filter() selects items.functools.reduce() combines items into an accumulated result.Functional programming is a useful approach for writing reusable, predictable, and testable Python code. By understanding first-class functions, pure functions, lambda expressions, higher-order functions, comprehensions, iterators, and generators, developers can build clear and efficient data-processing workflows.
Python does not require every part of an application to follow a purely functional style. Functional techniques can be combined with loops, classes, and other language features to produce readable and maintainable applications.
Continue learning with the Python Training Course at JustAcademy, register through the JustAcademy Demo Registration Page, or explore the JustAcademy Homepage.
For further reading, consult the official Python Functional Programming HOWTO to explore iterators, generators, higher-order functions, and functional-style techniques.
